#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
#include "personnage.h"
#include "interaction_T_P.h"
#include "terrain.h"
#include "gestion.h"
#include <SDL/SDL.h>


int Get_Numero (const _joueur* Joueur){
assert(Joueur != NULL);
return Joueur->Numero;
}

int Get_Humain (const _joueur* Joueur){
assert(Joueur != NULL);
return Joueur->Humain;
}

int Get_Courrant (const _joueur* Joueur){
assert(Joueur != NULL);
return Joueur->Courrant;
}

int Get_NbUnite (const _joueur* Joueur){
assert(Joueur != NULL);
return Joueur->NbUnite;
}

int Get_NbUniteJouee (const _joueur* Joueur){
assert(Joueur != NULL);
return Joueur->NbUniteJouee;
}



void Set_Numero (_joueur* Joueur, const int Numero){
assert(Joueur!= NULL);
Joueur->Numero = Numero;
assert(Joueur->Numero == Numero);
}

void Set_Courrant (_joueur* Joueur, const int Courrant ){
assert(Joueur!= NULL);
Joueur->Courrant = Courrant;
assert(Joueur->Courrant == Courrant);
}

void Set_NbUnite (_joueur* Joueur, int const NbUnite){
assert(Joueur!= NULL);
Joueur->NbUnite = NbUnite;
assert(Joueur->NbUnite == NbUnite);
}

void Set_NbUniteJouee (_joueur* Joueur, int const NbUniteJouee){
assert(Joueur!= NULL);
Joueur->NbUniteJouee = NbUniteJouee;
assert(Joueur->NbUniteJouee == NbUniteJouee);
}

void Set_Humain (_joueur* Joueur, int const Humain){
assert(Joueur!= NULL);
Joueur->Humain = Humain;
assert(Joueur->Humain == Humain);
}



_joueur* Init_Joueur ( int Numero){

_joueur* Joueur;
Joueur = (_joueur*)malloc ( sizeof (_joueur) );
Joueur->Numero  = Numero;
return Joueur;

}


void Libere_Joueur ( _joueur* Joueur){

free(Joueur);

}



/*Pour le moment cette fonction fait la même chose quelque soit le type
de personnage, pour des modifications future eventuelles on prépare des 
changement simple a mettre en place */

void Set_Debut_Tour ( _terrain* Terrain, _personnage* ListePersonnage){

int x,y;

for (x=0; x<Get_Dimx(Terrain); x++){
	for (y=0; y<Get_Dimy(Terrain); y++){
		if( Terrain->Cases[x][y] > 1){
			if ( ListePersonnage[Terrain->Cases[x][y]].Type == 1){
				ListePersonnage[Terrain->Cases[x][y]].Pm = PM1;
				ListePersonnage[Terrain->Cases[x][y]].Attk = Attk1;
			} 		

			if ( ListePersonnage[Terrain->Cases[x][y]].Type == 2){
				ListePersonnage[Terrain->Cases[x][y]].Pm = PM2;
				ListePersonnage[Terrain->Cases[x][y]].Attk = Attk2;
			} 		


			if ( ListePersonnage[Terrain->Cases[x][y]].Type == 3){
				ListePersonnage[Terrain->Cases[x][y]].Pm = PM3;
				ListePersonnage[Terrain->Cases[x][y]].Attk = Attk3;
			} 		



	
		}
	}
}

}


int Gagner (_joueur ListeJoueur[NBJOUEURMAX] ){
if ( (ListeJoueur[1].NbUnite == 0) && (ListeJoueur[2].NbUnite == 0) && (ListeJoueur[3].NbUnite == 0) )
	return 4;


if ( (ListeJoueur[1].NbUnite == 0) && (ListeJoueur[2].NbUnite == 0) && (ListeJoueur[4].NbUnite == 0) )
	return 3;

if ( (ListeJoueur[1].NbUnite == 0) && (ListeJoueur[3].NbUnite == 0) && (ListeJoueur[4].NbUnite == 0) )
	return 2;

if ( (ListeJoueur[2].NbUnite == 0) && (ListeJoueur[3].NbUnite == 0) && (ListeJoueur[4].NbUnite == 0) )
	return 1;

 return 0;
}



void Convert_Clic_Case(const SDL_Event Event, int* xy){


 switch(Event.type)
    {
        case SDL_MOUSEBUTTONUP:
            xy[0] = (Event.button.x)/TAILLECASE;
            xy[1] = (Event.button.y)/TAILLECASE;
            break;
    }

}


const _personnage* Recherche_Id ( const _personnage* ListePersonnage, const int Id){
int i = 0;
const _personnage* tmp = 0;

tmp = &ListePersonnage[i];
while ( tmp != &ListePersonnage[i]){
	i ++;
	tmp = &ListePersonnage[i];
	
} 

return tmp;

}

// Listepersonnage est un tableau contenant tous les personnage
void Tour (_joueur* Joueur, _terrain* Terrain, _personnage* ListePersonnage ){
Joueur->NbUniteJouee =0;
SDL_Event Event;
int xy[2];
int Compteur=2; 
_personnage* Select;
_personnage* Ennemi;

Joueur->NbUniteJouee = 3;

while ( Joueur->NbUniteJouee <= 3) { // grand while


SDL_WaitEvent(&Event);
Convert_Clic_Case(Event,xy);
if ( Terrain->Cases[xy[0]][xy[1]] >1){//if1
	
	while(ListePersonnage[Compteur].Id != Terrain->Cases[xy[0]][xy[1]])
		Compteur++;

		if ( ListePersonnage[Compteur].Joueur == Get_Numero (Joueur))
		{//if2
			Select = &ListePersonnage[Compteur];		
			SDL_WaitEvent(&Event);

		while(Get_Pm(Select) != 0 || Get_Po(Select) != 0 ) //while 3
		{
			switch(Event.type)
			{

				case SDL_KEYDOWN:
				switch(Event.key.keysym.sym)
				{
				    case SDLK_UP:
				        Deplacer_Perso (Select,2,Terrain);
					//affichage
					break;
				    case SDLK_DOWN:
					Deplacer_Perso (Select,4,Terrain);
					//affichage
					break;
				    case SDLK_RIGHT:
					Deplacer_Perso (Select,3,Terrain);
					//affichage
					break;
				    case SDLK_LEFT:
					Deplacer_Perso (Select,1,Terrain);
					//affichage
					break;
				    case SDLK_SPACE:
					Set_Pm(Select, 0);
					Set_Attk(Select, 0);
					break;	
				}//switch direction
				case SDL_MOUSEBUTTONDOWN:	    
					Convert_Clic_Case(Event,xy);
					Ennemi = Recherche_Id(ListePersonnage,Terrain->Cases[xy[0]][xy[1]]);			
					if (Get_Joueur(Ennemi) != Get_Numero(Joueur)) 
					{
						if ( Est_Accesible(Select,Ennemi) )
							Attaquer(Select,Ennemi);
					}
		    	}//switch event	  
		
		}//while3
		Joueur->NbUniteJouee++;
			}//if2

		}//if1


	} //grand while



}// fin fonction




